Skip to main content

App Open

App Open ads are full-screen ads that appear when users launch your app, providing an excellent opportunity to monetize app startup moments. Unlike interstitial ads, App Open ads are specifically designed for app launch scenarios and help create a smooth user experience during cold starts and app foregrounding events.

Key Features​

  • Launch Optimization: Designed specifically for app startup scenarios
  • User-Friendly: Integrates seamlessly with splash screens and loading experiences
  • Revenue Maximization: Monetizes high-engagement moments when users actively open your app
  • Retention-Focused: Built with user retention best practices in mind

Best Practices​

Implementation Guidelines
  • Always use a splash/loading screen before showing the App Open ad
  • Inform users about the upcoming ad with a message like "Watch an ad from our sponsor while the app loads"
  • Ensure proper sequence: Splash screen → App Open ad → App content
  • Initialize the SDK before loading App Open ads
Frequency Management

To maintain good user experience and retention:

  • Implement external frequency capping outside of the SDK
  • Consider cooldown periods between App Open ads
  • Wait for new users to engage with your app before showing their first App Open ad
  • Show ads strategically (e.g., every 2nd or 3rd app launch)

Start loading an ad​

Load App Open ads during SDK initialization, ideally in your Application class or main activity startup.

    XMediatorAds.startWith(
        activity = activity,
        appKey = APP_KEY,
        initCallback = {
            XMediatorAds.AppOpen.load(APP_OPEN_PLACEMENT_ID)
        }
    )

Showing an ad​

Show App Open ads when your app comes to the foreground. Check if an ad is ready before attempting to show it.

    if (XMediatorAds.AppOpen.isReady()) {
        XMediatorAds.AppOpen.show(activity, "app-open-ad-space")
    }

Showing an ad with placementId​

For specific placement targeting, use the placement-specific methods:

    if (XMediatorAds.AppOpen.isReady(APP_OPEN_PLACEMENT_ID)) {
        XMediatorAds.AppOpen.show(APP_OPEN_PLACEMENT_ID, activity, "app-open-ad-space")
    }

Built-in features​

Auto loading​

When App Open ads are dismissed or fail to show, the SDK automatically triggers a new load request to ensure the next app launch opportunity is ready.

Auto retry​

Failed load attempts are automatically retried with exponential backoff, ensuring optimal fill rates for your app launch monetization.

Additional settings​

Register ad callbacks​

Monitor App Open ad lifecycle events to implement custom logic and user experience flows:

    private val appOpenListener = object : AppOpenAds.Listener {
        override fun onLoaded(placementId: String, loadResult: LoadResult) {
            Log.d("Presenter", "App Open loaded. Placement $placementId, result: $loadResult")
        }

        override fun onShowed(placementId: String) {
            Log.d("Presenter", "App Open shown: $placementId.")
            // Hide splash screen here
        }

        override fun onFailedToShow(placementId: String, showError: ShowError) {
            // Continue to app content if ad fails to show
            Log.d("Presenter", "App Open failed to show $placementId, ${showError.message}")
            proceedToAppContent()
        }

        override fun onDismissed(placementId: String) {
            // User dismissed the ad, proceed to app content
            Log.d("Presenter", "App Open dismissed for placementId: $placementId")
            proceedToAppContent()
        }

        override fun onImpression(placementId: String, impressionData: ImpressionData) {
            Log.d("Presenter", "App Open impression for placementId: $placementId, data: $impressionData")
        }

        override fun onClicked(placementId: String) {
            Log.d("Presenter", "App Open clicked for placementId: $placementId")
        }
    }
    XMediatorAds.AppOpen.addListener(appOpenListener)

App Lifecycle Integration​

For optimal App Open ad implementation, integrate with Android's lifecycle events:

class MyApplication : Application(), LifecycleObserver {
    
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onAppForegrounded() {
        // App comes to foreground - show App Open ad if ready
        if (XMediatorAds.AppOpen.isReady()) {
            // Get current activity and show ad
            getCurrentActivity()?.let { activity ->
                XMediatorAds.AppOpen.show(activity, "app-open-ad-space")
            }
        }
    }
}

Code example​

Implementation example showing App Open ads with splash screen integration:

AppOpenSample.kt
import android.app.Activity
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.View
import android.widget.ProgressBar
import android.widget.TextView
import com.etermax.R
import com.etermax.xmediator.core.api.entities.ImpressionData
import com.etermax.xmediator.core.api.entities.LoadResult
import com.etermax.xmediator.core.api.entities.ShowError
import com.x3mads.android.xmediator.core.api.AppOpenAds
import com.x3mads.android.xmediator.core.api.XMediatorAds

class AppOpenSample : Activity() {
    private val appKey = "app_key"
    private val appOpenPlacementId = "placement_id"
    private var splashProgressBar: ProgressBar? = null
    private var splashMessage: TextView? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_splash)
        
        splashProgressBar = findViewById(R.id.splash_progress)
        splashMessage = findViewById(R.id.splash_message)
        
        // Show user-friendly message about upcoming ad
        splashMessage?.text = "Watch an ad from our sponsor while the app loads..."
        
        XMediatorAds.AppOpen.addListener(listener = appOpenListener)
        
        // Initialize SDK and load App Open ad
        XMediatorAds.startWith(
            activity = this,
            appKey = appKey,
            initCallback = {
                XMediatorAds.AppOpen.load(appOpenPlacementId)
            }
        )
        
        // Show ad after a short delay to ensure splash screen is visible
        Handler(Looper.getMainLooper()).postDelayed({
            showAppOpenAdIfReady()
        }, 2000)
    }

    private fun showAppOpenAdIfReady() {
        if (XMediatorAds.AppOpen.isReady(appOpenPlacementId)) {
            XMediatorAds.AppOpen.show(appOpenPlacementId, this, "app-open-ad-space")
        } else {
            // No ad ready, proceed to main app
            proceedToMainApp()
        }
    }

    private fun proceedToMainApp() {
        // Hide splash elements and show main app content
        splashProgressBar?.visibility = View.GONE
        splashMessage?.text = "Welcome to the app!"
        
        // Navigate to main activity or show main content
        // startActivity(Intent(this, MainActivity::class.java))
        // finish()
    }

    override fun onDestroy() {
        super.onDestroy()
        XMediatorAds.AppOpen.removeListener(listener = appOpenListener)
    }

    private val appOpenListener = object : AppOpenAds.Listener {
        override fun onLoaded(placementId: String, loadResult: LoadResult) {
            Log.d("AppOpenSample", "App Open loaded. Placement $placementId, result: $loadResult")
        }

        override fun onShowed(placementId: String) {
            Log.d("AppOpenSample", "App Open shown: $placementId.")
            // Hide splash screen when ad is shown
            splashProgressBar?.visibility = View.GONE
        }

        override fun onFailedToShow(placementId: String, showError: ShowError) {
            Log.d("AppOpenSample", "App Open failed to show $placementId, ${showError.message}")
            proceedToMainApp()
        }

        override fun onDismissed(placementId: String) {
            Log.d("AppOpenSample", "App Open dismissed for placementId: $placementId")
            proceedToMainApp()
        }

        override fun onImpression(placementId: String, impressionData: ImpressionData) {
            Log.d("AppOpenSample", "App Open impression for placementId: $placementId, data: $impressionData")
        }

        override fun onClicked(placementId: String) {
            Log.d("AppOpenSample", "App Open clicked for placementId: $placementId")
        }
    }
}

Advanced Use Cases​

Need more control over the ad loading and presentation lifecycle? Check out the Advanced App Open API for fine-grained control using individual AppOpen instances.